package com.eastjet.equipment.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.eastjet.equipment.mapper.DevicePmcsMapper;
import com.eastjet.equipment.mapper.DeviceSpotcheckMapper;
import com.eastjet.equipment.service.DevicePmcsService;
import com.eastjet.equipment.util.PageUtil;
import com.eastjet.equipment.util.RedisUtil;
import com.eastjet.maintenance.domain.DeviceInspectiontask;
import com.eastjet.maintenance.domain.DevicePmcs;

import com.eastjet.maintenance.domain.DeviceSpotcheck;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
* @author 杨博文
* @description 针对表【device_pmcs(点检任务表)】的数据库操作Service实现
* @createDate 2024-11-25 09:23:38
*/
@Service
public class DevicePmcsServiceImpl extends ServiceImpl<DevicePmcsMapper, DevicePmcs>
    implements DevicePmcsService {

    @Autowired
    private DevicePmcsMapper devicePmcsMapper;

    @Autowired
    private DeviceSpotcheckMapper deviceSpotcheckMapper;

    @Autowired
    private RedisUtil redisUtil;

    @Override
    public String addPmcs(DevicePmcs devicePmcs) {
        System.out.println("devicePmcs:" + devicePmcs.toString());
        try {
            System.out.println("更新设备维修经验库");
            // 尝试将数据插入数据库
            if (devicePmcsMapper.insert(devicePmcs) > 0) {
                // 定义Redis的键
                String redisKey = "PmcsList:";
                try {
                    // 从数据库获取当前所有数据
                    String condition="";
                    List<DevicePmcs> devicePmcsList = devicePmcsMapper.selectList(null); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, devicePmcsList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "添加成功";
            } else {
                return "添加失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "添加失败";
        }
    }

    @Override
    public Page<DevicePmcs> getPmcsList(int page, int size, String condition,String name) {
        // 定义Redis中的键
        String redisKey = "PmcsList:"+name;
        System.out.println("PmcsList-condition:"+condition);
        // 先查缓存Redis
        if (redisUtil.hasKey(redisKey)) {
            System.out.println(1);
            System.out.println("PmcsList-从Redis中获取数据");
            List<DevicePmcs> PmcsList;
            if (condition != null  && !condition.isEmpty() && condition !="") {
                System.out.println(2);
                PmcsList = devicePmcsMapper.pmcsList(condition,name); // 获取所有数据
            } else {
                System.out.println(3);
                PmcsList   = (List<DevicePmcs>) redisUtil.get(redisKey);
            }
            // 使用PageUtil进行分页
            return PageUtil.paginate(PmcsList, page, size);
        } else {
            System.out.println(4);
            System.out.println("在数据库中查询TaskList");
            List<DevicePmcs> PmcsList;

            // 根据condition条件查询
            if (condition != null && !condition.isEmpty() && condition !="") {
                System.out.println(5);
                condition="";
                PmcsList = devicePmcsMapper.pmcsList(condition,name); // 获取所有数据
            } else {
                System.out.println(6);
                condition="";
                PmcsList = devicePmcsMapper.pmcsList(condition,name); // 获取所有数据
                // 将数据存入Redis
                redisUtil.set(redisKey, PmcsList);
            }
            // 使用PageUtil进行分页
            return PageUtil.paginate(PmcsList, page, size);
        }
    }

    @Override
    public String updatePmcs(DevicePmcs devicePmcs) {
        System.out.println("devicePmcs:" + devicePmcs.toString());
        try {
            System.out.println("更新设备维修经验库");
            // 尝试将数据插入数据库

            UpdateWrapper uw=new UpdateWrapper();
            uw.set("pmcs_inspectionTaskType_id","执行中");
            uw.set("pmcs_time",devicePmcs.getPmcsTime());
            uw.set("pmcs_okontime",devicePmcs.getPmcsOkontime());
            uw.set("pmcs_okuntime",devicePmcs.getPmcsOkuntime());
            uw.eq("task_coding",devicePmcs.getTaskCoding());

            if (devicePmcsMapper.update(devicePmcs,uw) > 0) {
                // 定义Redis的键
                String redisKey = "PmcsList:";
                try {
                    // 从数据库获取当前所有数据
                    String condition="";
                    List<DevicePmcs> devicePmcsList = devicePmcsMapper.pmcsList(condition,""); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, devicePmcsList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "修改成功";
            } else {
                return "修改失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "修改失败";
        }
    }

    @Override
    public String updateSkip(DevicePmcs devicePmcs) {
        return "";
    }

    @Override
    public String adjustPmcs(DevicePmcs devicePmcs) {
        System.out.println("devicePmcs:" + devicePmcs.toString());
        try {
            System.out.println("更新设备维修经验库");
            // 尝试将数据插入数据库

            UpdateWrapper uw=new UpdateWrapper();
            uw.set("pmcs_inspectionTaskType_id","执行中");
            uw.set("cause",devicePmcs.getCause());
            uw.set("pmcs_okontime",devicePmcs.getPmcsOkontime());
            uw.set("pmcs_okuntime",devicePmcs.getPmcsOkuntime());
            uw.eq("task_coding",devicePmcs.getTaskCoding());
            UpdateWrapper uo=new UpdateWrapper();
            uo.set("spotCheck_class_id",devicePmcs.getDeviceSpotcheck().getSpotcheckClassId());
            uo.set("spotCheck_person",devicePmcs.getDeviceSpotcheck().getSpotcheckPerson());
            uo.eq("code",devicePmcs.getCode());
            if(deviceSpotcheckMapper.update(devicePmcs.getDeviceSpotcheck(),uo)>0){
                String redis="SpotplanList:";
                List<DeviceSpotcheck> deviceSpotcheckList = deviceSpotcheckMapper.schemeList("","",""); // 可以根据需要替换为实际查询条
                redisUtil.set(redis,deviceSpotcheckList);
            }
            if (devicePmcsMapper.update(devicePmcs,uw) > 0) {
                // 定义Redis的键
                String redisKey = "PmcsList:";
                try {
                    // 从数据库获取当前所有数据
                    String condition="";
                    List<DevicePmcs> devicePmcsList = devicePmcsMapper.pmcsList("",""); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, devicePmcsList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "修改成功";
            } else {
                return "修改失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "修改失败";
        }
    }
}




